Improved solution to the non-domination level update problem

Non-domination level update problem is to sort the non-dominated fronts after insertion or deletion of a solution. Generally the solution to this problem requires to perform the complete non-dominated sorting which is too expensive in terms of number of comparisons. Recently an Efficient Nondomination Level Update (ENLU) approach is proposed which does not perform the complete sorting. For this purpose, in this paper a space efficient version of ENLU approach is proposed without compromising the number of comparisons. However this approach does not work satisfactorily in all the cases. So we have also proposed another tree based approach for solving this nondomination level update problem. In case of insertion, the tree based approach always checks for same number of fronts unlike linear approach in which the number of fronts to be checked depends on the inserted solution. The result shows that in case where all the solutions are dominating in nature the maximum number of comparisons using tree based approach is O(logN) as opposed to O(N) in ENLU approach. When all the solutions are equally divided into K fronts such that each solution in a front is dominated by all the solutions in the previous front then the maximum number of comparisons to find a deleted solution in case of tree based approach is K− logK less than that of ENLU approach. Using these approaches an on-line sorting algorithm is also proposed and the competitive analysis of this algorithm is also presented. I . I N T R O D U C T I O N In past few decades the evolutionary algorithms [1], [2], [3], [4] have gained a lot of popularity. One of the primarily reason behind its popularity is their ability to solve real world problems. Real world problems may involve simultaneous optimizing multiple objectives. Thus the evolutionary algorithms also optimize single as well as multiple objectives. In case of single objective optimization, only single solution is optimal one. But in case of multi-objective optimization problems (MOOPs) [5], [6], [7], [8] a set of set of optimal solutions are achieved and these are known as Pareto-optimal solutions. In literature various multi-objective evolutionary algorithms (MOEAs) are proposed. Some of them are non-dominated sorting genetic algorithm II (NSGA-II) [9], strength pareto evolutionary algorithm 2 (SPEA2) [10], pareto archive evolution strategy (PAES) [11], pareto envelope-based selection algorithm (PESA) [12] and pareto frontier differential evolution (PDE) [13] etc. These MOEAs are able to find a set of Pareto optimal solutions in one single run. There exist various approaches for Front Solutions F1 sol1, sol2, . . . , soln1 F2 soln1+1, soln1+2, . . . , soln1+n2 .. .. FK soln1+···+nK-1+1, . . . , solN TABLE I: Solutions in K different fronts the selection of solutions [14]. But the Pareto-based approach is generally used. Non-dominated sorting [9] is found to be efficient for finding Pareto-optimal solution out of various techniques. In this sorting the solutions are assigned to their respective front based on their dominance relationship. This process is time consuming when the number of solutions in the populations becomes larger. Much work [9], [15], [16] has been done to improve the running time of this process. Golberg et al. [17] first proposed the idea of non-dominated sorting. Later this idea was used in multi-objective genetic algorithm [18]. Let P = {p1, p2, . . . , pN} be the population of N solutions. These solutions are categorized into K fronts. These K fronts are denoted as Fk, 1 ≤ k ≤ K. The solutions which belong to front Fk are dominated by at-least one of the solutions belonging to front F ′ k, k ′ < k, k, k′ = 1, 2, . . . ,K. Let the number of solutions in each front Fk is nk, 1 < k < K. Thus N = ∑K k=1 nk. The arrangement of the solutions in each front is shown in Table I. Consider an example. Example 1.1: Let P be a set of 12 solutions. Two objectives are associated with each solution. Let both the objectives are to be minimized. These 12 solutions are arranged in 5 fronts. The arrangement of solutions in each fronts is as follows: F1 = {p1}, F2 = {p2, p3}, F3 = {p4, p5, p6, p7}, F4 = {p8, p9, p10, p11}, F5 = {p12}. The generational Evolutionary Multi-Objective Optimization (EMO) algorithms generate all the offspring solutions from the parent solutions. Then they both are compared. As opposite to the generational EMO algorithms, steady state EMO algorithms [19], [20] update the parent population as a new offspring is derived. The steady state EMO algorithms have the ability to generate the good offspring solutions. The parallel implemenar X iv :1 51 0. 04 79 6v 1 [ cs .D S] 1 6 O ct 2 01 5 tation is also possible with this kind of EMO algorithms. There have not been so many such kind of EMO algorithms proposed [21]. One of the primarily reason for this is the overhead in repeatedly performing the non-dominated sorting as a new solution is generated or an existing solution is removed. But when either a new solution in inserted or an existing solution is removed then not all the solutions change its domination level so it is un-necessary to perform the complete non-dominated sorting again and again. Only some of the solutions need to change their non-domination level. This is first addressed in [21]. Li at al. [21] proposed an efficient non-domination level update (ENLU) approach for steadystate EMO algorithms. They have proposed the approach for insertion as well as deletion. In this approach not all the solutions change their domination level. The solutions which need to change their domination level, only change the level. After this some more work has been carried out in this direction [22], [23]. But these two work focus on bi-objective steady state EMO algorithms. So in this paper we have proposed the modified version of ENLU which is efficient in terms of space and time complexity remains the same. One more approach is provided which is based on tree data structure. The maximum number of dominance comparison while performing insertion or deletion is also obtained. In short the main contribution are as follows: • The modified linear approach with space requirement O(1) as opposite to O(N) in [21] is proposed. • The dominance tree based approach is proposed for nondomination level update problem. • We have obtained the maximum number of dominance comparisons occurred in linear as well as dominance tree based approach. • The approach for searching a solution is also proposed using dominance tree. • The solution to the non-domination level update problem can be used as a non-dominated sorting algorithm. This sorting algorithm can be used as on-line algorithm. The competitive ratio of this on-line algorithm is also obtained. The rest of this paper is organized as follows. Section II describes the Non-domination Level Update problem. The related work is also described in this Section. The modified linear approach to insert a solution in the given set of fronts is discussed in Section III. The Proposed dominance binary search tree based approach is illustrated in Section IV. The look up procedure using dominance binary search tree based approach is provided in Section V. The procedure to delete an existing solution is discussed in Section VI. Section VII discuss the maximum number of dominance comparison in Non-domination Level Update problem. In section VIII and IX we discuss the maximum and minimum number of dominance comparison in two cases when al the solutions are nondominating and when all are dominating respectively. The sorting algorithm using the proposed approach is presented in Section X. Finally Section XI concludes the paper and provides the future direction of the work. I I . N O N D O M I N AT I O N L E V E L U P D AT E P R O B L E M In this section we discuss the non-domination level update problem. Non-domination Level Update problem is to sort the non-dominating front after insertion of a new solution or after deletion of an existing solution. Let P = {sol1, sol2, . . . , solN} be the set of N solutions. Let M objectives are associated with these N solutions. These N solutions are divided into K fronts. Let F = {F1, F2, . . . , FK−1, FK} be the set of K fronts in decreasing order of their dominance i.e., the first front is having rank 1 (non-domination level 1), second is having rank 2 and so on. The number of solutions in each front Fi is given by ni, 1 ≤ i ≤ K. Thus ∑K i=1 ni = N . Table I shows this scenario. Let a new solution new is to be inserted into the set of K fronts. Non-domination Level Update problem in case of insertion is to insert this new solution at its correct position in the set of fronts and update the fronts if needed. Figure 1a clearly shows this situation. In this figure, there are 9 solutions. Let P = {1, 2, . . . , 9} be the set of these 9 solutions. These solutions are divided into 4 fronts. Let F = {F1, F2, F3, F4} be the set of 4 fronts in the decreasing order of their dominance. F1 = {2}, F2 = {1, 3, 6}, F3 = {4, 8}, F4 = {5, 7, 9}. A new solution new is to be inserted in the set of fronts. Main aim here is to update F after insertion of new. Figure 1b shows the updated set of fronts when new solution is inserted in the set of fronts. Let an existing solution sol is to be deleted from the set of K fronts. Non-domination Level Update problem in case of deletion is to delete this solution and update the set of fronts if required. Figure 1a shows the set of 4 fronts. An existing solution 4 is to be deleted from the set of fronts. The motive is to update F after deletion of solution 4. Figure 1c shows the updated set of fronts when solution 4 is being deleted from the set of fronts. The naive approach is to apply the non-dominated sorting algorithm on all the N solutions along with new solution in case of insertion or apply the non-dominated sorting algorithm on the remaining N−1 solutions in case of deletion. Thus the complete sorting algorithm is to be applied on either N+1 or N−1 solutions. If we use the brute-force technique then the time complexity will be O(MN) and space requirement will be O(N). When the fast non-dominating sorting proposed in [9] is used then the time complexity will be O(MN). This always requires (N+1)N dominance comparison in case of insertion and (N−1)(N−2) comparison in case of deletion regardless of arrangement of fronts. The space requirement will be O(N). Tang et al. [24] proposed arena’s principle. The time complexity of their approach is O(MN) in worst case. The space requirement is O(N). McClymont et al. [15] proposed two sorting algorithms climbing sort and deductive sort. The climbing sort requires (N+1)N comparison in case of insertion and (N−1)(N−2) comparison in case of deletion when the worst case scenario occurs. The space requirement is O(N). The deductive sort has some advantage over climbing. In the worst case the number of comparison is (N+1)N 2 for (a) Set of fronts F before insertion of new. (b) Set of fronts F after insertion of new. (c) Set of fronts F after deletion of 4. Fig. 1: Schematic diagram of Non-domination Level Update problem in case of insertion. insertion and (N−1)(N−2) 2 for deletion. The space requirement is O(N) as opposite to O(N) by climbing sort. The approach proposed in [16] requires O(MN) time in worst case. In the worst case the total number of dominance comparison is same as deductive sort. This approach first sorts the solutions based on first objective which also requires O(N logN) time. The space requirement of this approach is O(1). All the above discussed approaches apply the complete sorting algorithm on either N+1 or N−1 solutions. To reduce the number of dominance comparisons without applying the complete sorting algorithm, Li et al. [21] proposed an approach for Non-domination Level Update problem. The approach was proposed for Steady-State Evolutionary Multiobjective Optimization. The time complexity is O(MN √ N) in case of equal division of solutions in √ N fronts. However the worst case time complexity is O(MN) [22], [23]. The space requirement is O(N) as the dominated solution is kept at tow places one is in archive S and other is in front Fi+1. Yakupov et al. [22] proposed an incremental non-dominated sorting for bi-objective solutions. The running time of the approach is O(M(1 + log(N/M)) + logM log(N/ logM)) which is O(N) in worst case when a new solution is inserted in the set of fronts having N solutions with M objectives. With further improvement in this work, Buzdalov et al. [23] proposed fast implementation of the steady-State NSGA-II algorithm for two dimensions based on incremental non-dominated sorting. In this work, the support of the crowding distance calculation is employed. After that, the steady-state version of the NSGA-II algorithm is presented. In [22] and [23] a data structure tree of tress is used. The nodes in higher level tree stores the number of tree elements in a sub-tree, the previous-in-order node and the next-in-order node. Thus extra space is required which is O(K). The nodes in lower level tree also stores the number of tree elements in a sub-tree, the previous-in-order node and the next-in-order node. Thus extra space is required which is O(N). Thus the space requirement is O(K)+O(N) ≡ O(N). We have proposed an approach based on dominance binary search tree. First we discuss the modified version of linear approach proposed in [21] for insertion as well as deletion. The modification is done to reduce the space complexity from O(N) to O(1). I I I . M O D I F I E D L I N E A R A P P R O A C H : I N S E R T A S O L U T I O N In this section we will discuss the Non-domination Level Update problem using linear way to obtain the correct position of new solution new as done in [21]. Algorithm 1 shows the insertion procedure of new in the list of non-dominated fronts F . This algorithm does not run the complete sorting algorithm again. It uses the non-dominance properties of the solution in the same front and uses the ranking of the front. Here we are assuming that all the fronts are arranged in decreasing order of their dominance. The process for inserting a solution is summarized in Algorithm 1. Two solutions are compared for dominance nature using domNature(A,B) procedure which returns the following three values. • 1: Solution A dominates B. • -1: Solution A is dominated by B. • 0: Solution A and B are non-dominated. The new solution new is compared with all the fronts in sequential manner starting from F1 to FK . new is compared with each solution in a front. When new is compared with any solution in a front Fk(1 ≤ k ≤ K) then there are three possibilities: 1. If the solution in the front Fk dominates new it means new can not be inserted into Fk. So now we check for another front having lower dominance (Fk+1) without checking it with other solutions in the same front. If i = K then new creates a new front FK+1 having lowest dominance among all the fronts. 2. If the solution in the front is non-dominating with the new then we keep on comparing new with rest of the solutions in that front. If new is non-dominating with all the solutions in the front Fk then new is added in the front Fk. 3. If new dominates the solution in the front Fk then we obtain the list newdom of all the solutions in the front Fk which are dominated by new using DomSet() procedure as described in Algorithm 2. This DomSet() procedure returns the list of all the solutions in front Fk which are dominated by new. The solutions which are dominated by new are removed from front Fk. After the removal of dominated solution in Fk, new is added to Fk. Now we have the following possibilities: • If k = K then newdom creates a new front FK+1 having lowest dominance among all the fronts. Algorithm 1 InsertLinear(F , new) Input: F = {F1, F2, . . . , FK}: Non-dominated fronts in the decreasing order of their dominance new: A new solution Output: Updated F after insertion of new 1: for i← 1 to K do 2: count← 0 3: newdom ← Φ 4: for j ← 1 to |Fi| do 5: isdom← domNature(new, Fi(j)) 6: if isdom = 1 then 7: newdom ← newdom ∪ {Fi(j)} 8: Fi ← Fi \ {Fi(j)} 9: DomSet(Fi, new, i, newdom) 10: Fi ← Fi ∪ new 11: if i = K then 12: Make newdom a new front FK+1 13: else if |Fi| = 1 then 14: Increase the dominance level of all the fronts Fk+1, Fk+2, . . . , FK by 1 and make newdom a new front Fk+1 15: else 16: UpdateInsert(F , newdom, i+1) 17: return F 18: else if isdom = 0 then 19: count← count + 1 20: else 21: break 22: if count = |Fi| then 23: Insert new in Fi /* new is non-dominated with Fi 24: return F 25: Make new a new front FK+1 26: return F Algorithm 2 DomSet(F, new, index, S) Input: F : A non-dominated front new: A new solution index: Index of the solution from where the dominance need to be checked S: Set of solutions dominated by new Output: Updated S 1: for i← index to |F | do 2: isdom← domNature(new, F (i)) 3: if isdom = 1 then 4: S ← S ∪ {F (i)} 5: F ← F \ F (i) 6: i← i−1 7: return S • If new dominates all the solutions in the front (after removing the dominated solutions from Fk and adding new to Fk the cardinality of Fk is 1) i.e. |Fk| = 1 then the dominance level of all the fronts Fk+1, Fk+2, . . . , FK are increased by one and dominated solution newdom is assigned to front Fk+1. • If none of the above two conditions are satisfied i.e. new dominates some of the solutions in front Fk and k < K then UpdateInsert() procedure is used which re-arranges the solutions in their respective front. This UpdateInsert() procedure is discussed in Algorithm 3. A. Illustration of DomSet(F, new, index, S) procedure This procedure takes as input a front (F ), new solution (new), the index of the solution (index) in the front from where the dominance of new needs to be checked and set of solutions dominated by new (S). This procedure returns the updated set of solutions dominated by new in front F . For this purpose new is checked against all the solutions in the front starting from index position. The solution which is dominated by new is added to S and removed from the front F . We are removing the dominated solutions from the front to save the space. In this manner same solution does not occupy more than one place. Complexity Analysis: In the worst case, all the solutions in the front except first is compared with new solution in the DomSet() procedure so the worst case complexity of DomSet() procedure becomes O(M |F |). Algorithm 3 UpdateInsert(F , S, index) Input: F : Set of non-dominated fronts index: Non-domination level index Output: Updated F 1: l← |S| 2: for i← 1 to |Findex| do 3: count← 0 4: for j ← 1 to l do 5: if domNature(S(j), Findex(i)) = 0 then 6: count← count+1 7: if count = l then 8: S ← S ∪ Findex(i) 9: Findex ← Findex \ Findex(i) 10: i← i− 1 11: if l = |S| then 12: Increase the domination level of Fk, k ∈ {index, index+1, . . . ,K} by 1 and make S a new front Findex 13: else if Findex = Φ then 14: Make S as Findex 15: else 16: T ← Findex /*Move the solutions from Findex to T 17: Make S as Findex 18: UpdateInsert(F , T, index+1) B. Illustration of UpdateInsert(F , S, index) procedure This procedure takes as input the set of non-dominated fronts F , a set of solution S, the index of the front denoted by index in F . This procedure updates the F by either creating a new front or by re-arranging the solutions in the existing fronts. First of all the initial cardinality of S is stored is l. This is because when the solutions from Findex is compared with S for non-dominance then it should be compared with only first l solutions. Here we find the solutions in Findex which are non-dominated with S. The solutions which are non-dominated with S are added to it and removed from Findex. The removal guarantees that no solution can occupy more than one place. Now the following situation can occur: • If no solution from Findex is being added to S i.e. l = |S| then the dominance level of fronts Fk, k ∈ {index, index+1, . . . ,K} is increased by 1 and S is assigned the dominance level index. • If all the solutions from Findex is added to S i.e. Findex = Φ then make S as Findex. • Otherwise all the solutions from Findex is moved to T . The movement means as a solution from Findex is moved to T , the solution is being removed from Findex. The nondomination level of Findex is assigned to S. The procedure is repeated with UpdateInsert(F , T, index+1). Complexity Analysis: In this algorithm the maximum number of comparison is performed when new dominates the solutions in the first front F1 i.e. this procedure is called with index = 2. For maximum number of comparison, the |newdom| = n1−1. The maximum number of comparison occurs when each call to this procedure shifts one solution in higher level front after comparing with all the solutions. Thus the maximum number of comparison for this procedure is given by (n1−1)n2 + (n2−1)n3 + . . . + (nk−1−1)nK . Each comparison between two solutions requires at-most M comparison between M objectives. Thus the worst case complexity of this procedure is O(MN). The best case occurs when F1 has single solution and new is non-dominating with this solution. In this case only one comparison is required so the best case complexity is O(M). C. Complexity of Modified Linear Approach Here we will analyze the complexity using the linear approach. We can see from all the algorithms 1, 2 and 3 that no solution is being kept at more than one place. Only few scaler variables are required. Therefore, the space complexity of linear approach is O(1). The worst case time complexity of UpdateInsert() procedure dominates the worst case time complexity of DomSet() procedure. The complexity of UpdateInsert() procedure is quadratic while DomSet() has linear complexity. Thus the overall worst case complexity of the modified approach is O(MN). This time complexity is same as proposed in [21]. I V. P R O P O S E D A P P R O A C H U S I N G D O M I N A N C E B I N A RY S E A R C H T R E E In this section we will discuss the proposed approach for Nondomination Level Update problem using dominance tree. This approach inserts the new solution to its correct position using tree based methodology unlike linear way as proposed in [21]. The only difference between the linear approach and tree based approach is in identifying the position of the inserted solution. The update procedure remains the same. Thus dominance tree based approach will be beneficial when there are large number of fronts. We first provide formal definition of this tree. Two variants of this tree are also discussed. The tree based data structure is also used in [22] and [23]. The authors have used tree of trees where the high level tree corresponds to the non-dominated front i.e. node in the high level tree corresponds to a front. The low level tree corresponds to the solutions inside a front i.e. the nodes in the low level tree corresponds to solutions inside the front. The solutions in the low level tree are sorted according to first objective. The high-level tree can be an ordinary balanced tree while the low level tree should be a split-merge tree. The uses of this data structure perform some of the operations in O(logN) time like element search in the container, splitting of container by key into two parts and merging of two container. In [23], Cartesian Tree [25] is used as a split-merge tree as it performs better than the Splay Tree [26] in practice. We have used only high level tree named as Dominance Binary Search Tree. The solutions inside a node are arranged in linear fashion. Thus no sorting is required. A. Dominance Binary Search Tree In Dominance Binary Search Tree, the node represents single non-dominated front i.e., the solutions in a node are nondominating with each other. Definition 1 (Dominance Binary Search Tree): A binary tree T is known as Dominance Binary Search Tree if the node is having lower dominance than left sub-tree and higher dominance than right sub-tree. Example 4.1: Let F = {F1, F2, . . . , F15} be the set of 15 non-dominated fronts in decreasing order of their dominance i.e., the first front is having rank 1 (higher rank), second is having rank 2 and so on. The corresponding Dominance Binary Search Tree is given in Figure 2a. Dominance binary search tree can be categorized into two types based on how the root of a sub-tree is chosen. 1) Left-Balanced Dominance Binary Search Tree: If left child of each node is filled before the right child then the tree is called left-balanced dominance binary search tree. It is obtained when the index of the root of a sub-tree is calculated as mid = d(min + max)/2e. See Figure 2b. 2) Right-Balanced Dominance Binary Search Tree: If right child of each node is filled before the left child then the tree is called right-balanced dominance binary search tree. It is obtained when the index of the root of a sub-tree is calculated as mid = b(min + max)/2c. See Figure 2c. (a) Dominance Binary Search Tree (b) Left-Balanced Dominance BST (c) Right-Balanced Dominance BST Fig. 2: Dominance Binary Search Tree Unlike the linear approach where new needs to be compared with all the K fronts in the worst case, here the solution is compared with either blog2Kc+ 1 or blog2Kc fronts in all the cases. The process to insert a new solution new in the set of fronts F is summarized in Algorithm 4. B. Illustration of Algorithm 4 Algorithm 4 shows the insertion procedure of a new solution in the fronts using dominance binary search tree approach. Here like linear approach, we are also assuming that all the fronts are arranged in decreasing order of their dominance. This insertion can make the following changes in the tree. I. new can make new front i.e., creation of a new node. II. new can be merged with any of the existing fronts. III. new can be merged with any of the fronts by removing some of the solutions (which are dominated by newdom) in that front. After this removal, the solutions in the lower dominance fronts are re-arranged. With the help of Algorithm 4 a new solution new is inserted in the given list of fronts. If there is only single front then Algorithm 1 is called. Here the insertion is performed in the same manner as in linear approach. So in case of single front i.e. when all the solutions are non-dominating in nature then the linear approach and dominance tree based approach is same. If the number of fronts are more than one then the dominance binary search tree approach comes into picture. This algorithm first executes Algorithm 5 which gives a list known as CmpFront. In place of Algorithm 5 which is based on Left Dominance Binary Search Tree, Algorithm 6 can also be used which is based on Right Dominance Binary Search Tree. Algorithm 5 and 6 returns a list CmpFront. Each element of this list is 3-folded . ‘dom’ is the dominating nature of new with a particular solution in the front. ‘fIndex’ is the index of the front to which the new is compared and ‘sIndex’ is the index of the solution in FfIndex to which new is compared and ’dom’ is achieved. Thus ‘dom’ shows the dominated nature of new with FfIndex(sIndex). The ‘dom’ can take three values −1, 0, 1. The value of ‘fIndex’ can vary between 1 to K. Generally the value of ‘sIndex’ can vary between 1 to nk, 1 ≤ k ≤ K but when new is non-dominating with all the solutions in a particular front then the value of ‘sIndex’ is 0. The maximum length of this list is blog2Kc+ 1 because the maximum number of fronts to which new can be compared is blog2Kc+ 1. Algorithm 4 InsertTree(F , new) Input: F = {F1, F2, . . . , FK}: Non-dominated front in the decreasing order of their dominance new: A new solution Output: Updated F after insertion of new 1: if |F| = 1 then 2: Insert(F , new) /* Same as linear approach 3: else 4: CmpFront[] ← Φ 5: InsertTree Left(F , 1, |F|, new) 6: len← CmpFront.size() 7: if CmpFront[len]dom = 0 then 8: Insert new in FCmpFront[len]fIndex 9: else if CmpFront[len]dom = 1 then 10: newdom ← Φ 11: fIndex← CmpFront[len]fIndex 12: sIndex← CmpFront[len]sIndex 13: newdom ← newdom ∪ FfIndex(sIndex) 14: FfIndex ← FfIndex \ FfIndex(sIndex) 15: DomSet(FfIndex, new, sIndex+1, newdom) 16: FfIndex ← FfIndex ∪ new 17: if fIndex = K then 18: Make newdom a new front FfIndex+1 19: else if |FfIndex| = 1 then 20: Increase the dominance level of all fronts FfIndex+1, FfIndex+2, . . . ,K by 1 and make newdom a new front FfIndex+1 21: else 22: Update(F , newdom, fIndex+1) 23: else if All the dom value in CmpFront is -1 then 24: Make newdom a new front FK+1 25: else 26: for i← len to 2 do 27: if CmpFront[i]dom 6= CmpFront[i-1]dom then 28: fIndex← CmpFront[i-1]fIndex 29: sIndex← CmpFront[i-1]sIndex 30: if CmpFront[i-1]dom = 0 then 31: Insert new in FfIndex 32: else if CmpFront[i-1]dom = 1 then